home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / doom / quake.zip / HIPGRAPL.ZIP / SUBS.QC < prev    next >
Text File  |  1997-01-16  |  6KB  |  317 lines
  1.  
  2.  
  3. void() SUB_Null = {};
  4.  
  5. void() SUB_Remove = {remove(self);};
  6.  
  7.  
  8. /*
  9. QuakeEd only writes a single float for angles (bad idea), so up and down are
  10. just constant angles.
  11. */
  12. vector() SetMovedir =
  13. {
  14.     if (self.angles == '0 -1 0')
  15.         self.movedir = '0 0 1';
  16.     else if (self.angles == '0 -2 0')
  17.         self.movedir = '0 0 -1';
  18.     else
  19.     {
  20.         makevectors (self.angles);
  21.         self.movedir = v_forward;
  22.     }
  23.     
  24.     self.angles = '0 0 0';
  25. };
  26.  
  27. /*
  28. ================
  29. InitTrigger
  30. ================
  31. */
  32. void() InitTrigger =
  33. {
  34. // trigger angles are used for one-way touches.  An angle of 0 is assumed
  35. // to mean no restrictions, so use a yaw of 360 instead.
  36.     if (self.angles != '0 0 0')
  37.         SetMovedir ();
  38.     self.solid = SOLID_TRIGGER;
  39.     setmodel (self, self.model);    // set size and link into world
  40.     self.movetype = MOVETYPE_NONE;
  41.     self.modelindex = 0;
  42.     self.model = "";
  43. };
  44.  
  45. /*
  46. =============
  47. SUB_CalcMove
  48.  
  49. calculate self.velocity and self.nextthink to reach dest from
  50. self.origin traveling at speed
  51. ===============
  52. */
  53. void(entity ent, vector tdest, float tspeed, void() func) SUB_CalcMoveEnt =
  54. {
  55. local entity    stemp;
  56.     stemp = self;
  57.     self = ent;
  58.  
  59.     SUB_CalcMove (tdest, tspeed, func);
  60.     self = stemp;
  61. };
  62.  
  63. void(vector tdest, float tspeed, void() func) SUB_CalcMove =
  64. {
  65. local vector    vdestdelta;
  66. local float        len, traveltime;
  67.  
  68.     if (!tspeed)
  69.         objerror("No speed is defined!");
  70.  
  71.     self.think1 = func;
  72.     self.finaldest = tdest;
  73.     self.think = SUB_CalcMoveDone;
  74.  
  75.     if (tdest == self.origin)
  76.     {
  77.         self.velocity = '0 0 0';
  78.         self.nextthink = self.ltime + 0.1;
  79.         return;
  80.     }
  81.         
  82. // set destdelta to the vector needed to move
  83.     vdestdelta = tdest - self.origin;
  84.     
  85. // calculate length of vector
  86.     len = vlen (vdestdelta);
  87.     
  88. // divide by speed to get time to reach dest
  89.     traveltime = len / tspeed;
  90.  
  91.     if (traveltime < 0.1)
  92.     {
  93.         self.velocity = '0 0 0';
  94.         self.nextthink = self.ltime + 0.1;
  95.         return;
  96.     }
  97.     
  98. // set nextthink to trigger a think when dest is reached
  99.     self.nextthink = self.ltime + traveltime;
  100.  
  101. // scale the destdelta vector by the time spent traveling to get velocity
  102.     self.velocity = vdestdelta * (1/traveltime);    // qcc won't take vec/float    
  103. };
  104.  
  105. /*
  106. ============
  107. After moving, set origin to exact final destination
  108. ============
  109. */
  110. void()  SUB_CalcMoveDone =
  111. {
  112.     setorigin(self, self.finaldest);
  113.     self.velocity = '0 0 0';
  114.     self.nextthink = -1;
  115.     if (self.think1)
  116.         self.think1();
  117. };
  118.  
  119.  
  120. /*
  121. =============
  122. SUB_CalcAngleMove
  123.  
  124. calculate self.avelocity and self.nextthink to reach destangle from
  125. self.angles rotating 
  126.  
  127. The calling function should make sure self.think is valid
  128. ===============
  129. */
  130. void(entity ent, vector destangle, float tspeed, void() func) SUB_CalcAngleMoveEnt =
  131. {
  132. local entity        stemp;
  133.     stemp = self;
  134.     self = ent;
  135.     SUB_CalcAngleMove (destangle, tspeed, func);
  136.     self = stemp;
  137. };
  138.  
  139. void(vector destangle, float tspeed, void() func) SUB_CalcAngleMove =
  140. {
  141. local vector    destdelta;
  142. local float        len, traveltime;
  143.  
  144.     if (!tspeed)
  145.         objerror("No speed is defined!");
  146.         
  147. // set destdelta to the vector needed to move
  148.     destdelta = destangle - self.angles;
  149.     
  150. // calculate length of vector
  151.     len = vlen (destdelta);
  152.     
  153. // divide by speed to get time to reach dest
  154.     traveltime = len / tspeed;
  155.  
  156. // set nextthink to trigger a think when dest is reached
  157.     self.nextthink = self.ltime + traveltime;
  158.  
  159. // scale the destdelta vector by the time spent traveling to get velocity
  160.     self.avelocity = destdelta * (1 / traveltime);
  161.     
  162.     self.think1 = func;
  163.     self.finalangle = destangle;
  164.     self.think = SUB_CalcAngleMoveDone;
  165. };
  166.  
  167. /*
  168. ============
  169. After rotating, set angle to exact final angle
  170. ============
  171. */
  172. void() SUB_CalcAngleMoveDone =
  173. {
  174.     self.angles = self.finalangle;
  175.     self.avelocity = '0 0 0';
  176.     self.nextthink = -1;
  177.     if (self.think1)
  178.         self.think1();
  179. };
  180.  
  181.  
  182. //=============================================================================
  183.  
  184. void() DelayThink =
  185. {
  186.     activator = self.enemy;
  187.     SUB_UseTargets ();
  188.     remove(self);
  189. };
  190.  
  191. /*
  192. ==============================
  193. SUB_UseTargets
  194.  
  195. the global "activator" should be set to the entity that initiated the firing.
  196.  
  197. If self.delay is set, a DelayedUse entity will be created that will actually
  198. do the SUB_UseTargets after that many seconds have passed.
  199.  
  200. Centerprints any self.message to the activator.
  201.  
  202. Removes all entities with a targetname that match self.killtarget,
  203. and removes them, so some events can remove other triggers.
  204.  
  205. Search for (string)targetname in all entities that
  206. match (string)self.target and call their .use function
  207.  
  208. ==============================
  209. */
  210. void() SUB_UseTargets =
  211. {
  212.     local entity t, stemp, otemp, act;
  213.  
  214. //
  215. // check for a delay
  216. //
  217.     if (self.delay)
  218.     {
  219.     // create a temp object to fire at a later time
  220.         t = spawn();
  221.         t.classname = "DelayedUse";
  222.         t.nextthink = time + self.delay;
  223.         t.think = DelayThink;
  224.         t.enemy = activator;
  225.         t.message = self.message;
  226.         t.killtarget = self.killtarget;
  227.         t.target = self.target;
  228.         return;
  229.     }
  230.     
  231.     
  232. //
  233. // print the message
  234. //
  235.     if (activator.classname == "player" && self.message != "")
  236.     {
  237.         centerprint (activator, self.message);
  238.         if (!self.noise)
  239.             sound (activator, CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
  240.     }
  241.  
  242. //
  243. // kill the killtagets
  244. //
  245.     if (self.killtarget)
  246.     {
  247.         t = world;
  248.         do
  249.         {
  250.             t = find (t, targetname, self.killtarget);
  251.             if (!t)
  252.                 return;
  253.             remove (t);
  254.         } while ( 1 );
  255.     }
  256.     
  257. //
  258. // fire targets
  259. //
  260.     if (self.target)
  261.     {
  262.         act = activator;
  263.         t = world;
  264.         do
  265.         {
  266.             t = find (t, targetname, self.target);
  267.             if (!t)
  268.             {
  269.                 return;
  270.             }
  271.             stemp = self;
  272.             otemp = other;
  273.             self = t;
  274.             other = stemp;
  275.             if (self.use != SUB_Null)
  276.             {
  277.                 if (self.use)
  278.                     self.use ();
  279.             }
  280.             self = stemp;
  281.             other = otemp;
  282.             activator = act;
  283.         } while ( 1 );
  284.     }
  285.     
  286.  
  287. };
  288.  
  289.  
  290. /*
  291.  
  292. in nightmare mode, all attack_finished times become 0
  293. some monsters refire twice automatically
  294.  
  295. */
  296.  
  297. void(float normal) SUB_AttackFinished =
  298. {
  299.     self.cnt = 0;        // refire count for nightmare
  300.     if (skill != 3)
  301.         self.attack_finished = time + normal;
  302. };
  303.  
  304. float (entity targ) visible;
  305.  
  306. void (void() thinkst) SUB_CheckRefire =
  307. {
  308.     if (skill != 3)
  309.         return;
  310.     if (self.cnt == 1)
  311.         return;
  312.     if (!visible (self.enemy))
  313.         return;
  314.     self.cnt = 1;
  315.     self.think = thinkst;
  316. };
  317.